home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / BYacc-CW 1.9 / verbose.c < prev    next >
Text File  |  1995-05-20  |  6KB  |  320 lines
  1.  
  2. #include "defs.h"
  3.  
  4.  
  5. static short *null_rules;
  6.  
  7.  
  8. static void log_unused(void)
  9. {
  10.     register int i;
  11.     register short *p;
  12.  
  13.     fprintf(verbose_file, "\n\nRules never reduced:\n");
  14.     for (i = 3; i < nrules; ++i)
  15.     {
  16.     if (!rules_used[i])
  17.     {
  18.         fprintf(verbose_file, "\t%s :", symbol_name[rlhs[i]]);
  19.         for (p = ritem + rrhs[i]; *p >= 0; ++p)
  20.         fprintf(verbose_file, " %s", symbol_name[*p]);
  21.         fprintf(verbose_file, "  (%d)\n", i - 2);
  22.     }
  23.     }
  24. }
  25.  
  26.  
  27. static void log_conflicts(void)
  28. {
  29.     register int i;
  30.  
  31.     fprintf(verbose_file, "\n\n");
  32.     for (i = 0; i < nstates; i++)
  33.     {
  34.     if (SRconflicts[i] || RRconflicts[i])
  35.     {
  36.         fprintf(verbose_file, "State %d contains ", i);
  37.         if (SRconflicts[i] == 1)
  38.         fprintf(verbose_file, "1 shift/reduce conflict");
  39.         else if (SRconflicts[i] > 1)
  40.         fprintf(verbose_file, "%d shift/reduce conflicts",
  41.             SRconflicts[i]);
  42.         if (SRconflicts[i] && RRconflicts[i])
  43.         fprintf(verbose_file, ", ");
  44.         if (RRconflicts[i] == 1)
  45.         fprintf(verbose_file, "1 reduce/reduce conflict");
  46.         else if (RRconflicts[i] > 1)
  47.         fprintf(verbose_file, "%d reduce/reduce conflicts",
  48.             RRconflicts[i]);
  49.         fprintf(verbose_file, ".\n");
  50.     }
  51.     }
  52. }
  53.  
  54.  
  55. static void print_conflicts(int state)
  56. {
  57.     register int symbol, act, number;
  58.     register action *p;
  59.  
  60.     symbol = -1;
  61.     for (p = parser[state]; p; p = p->next)
  62.     {
  63.     if (p->suppressed == 2)
  64.         continue;
  65.  
  66.     if (p->symbol != symbol)
  67.     {
  68.         symbol = p->symbol;
  69.         number = p->number;
  70.         if (p->action_code == SHIFT)
  71.         act = SHIFT;
  72.         else
  73.         act = REDUCE;
  74.     }
  75.     else if (p->suppressed == 1)
  76.     {
  77.         if (state == final_state && symbol == 0)
  78.         {
  79.         fprintf(verbose_file, "%d: shift/reduce conflict \
  80. (accept, reduce %d) on $end\n", state, p->number - 2);
  81.         }
  82.         else
  83.         {
  84.         if (act == SHIFT)
  85.         {
  86.             fprintf(verbose_file, "%d: shift/reduce conflict \
  87. (shift %d, reduce %d) on %s\n", state, number, p->number - 2,
  88.                 symbol_name[symbol]);
  89.         }
  90.         else
  91.         {
  92.             fprintf(verbose_file, "%d: reduce/reduce conflict \
  93. (reduce %d, reduce %d) on %s\n", state, number - 2, p->number - 2,
  94.                 symbol_name[symbol]);
  95.         }
  96.         }
  97.     }
  98.     }
  99. }
  100.  
  101.  
  102. static void print_core(int state)
  103. {
  104.     register int i;
  105.     register int k;
  106.     register int rule;
  107.     register core *statep;
  108.     register short *sp;
  109.     register short *sp1;
  110.  
  111.     statep = state_table[state];
  112.     k = statep->nitems;
  113.  
  114.     for (i = 0; i < k; i++)
  115.     {
  116.     sp1 = sp = ritem + statep->items[i];
  117.  
  118.     while (*sp >= 0) ++sp;
  119.     rule = -(*sp);
  120.     fprintf(verbose_file, "\t%s : ", symbol_name[rlhs[rule]]);
  121.  
  122.         for (sp = ritem + rrhs[rule]; sp < sp1; sp++)
  123.         fprintf(verbose_file, "%s ", symbol_name[*sp]);
  124.  
  125.     putc('.', verbose_file);
  126.  
  127.     while (*sp >= 0)
  128.     {
  129.         fprintf(verbose_file, " %s", symbol_name[*sp]);
  130.         sp++;
  131.     }
  132.     fprintf(verbose_file, "  (%d)\n", -2 - *sp);
  133.     }
  134. }
  135.  
  136.  
  137. static void print_nulls(int state)
  138. {
  139.     register action *p;
  140.     register int i, j, k, nnulls;
  141.  
  142.     nnulls = 0;
  143.     for (p = parser[state]; p; p = p->next)
  144.     {
  145.     if (p->action_code == REDUCE &&
  146.         (p->suppressed == 0 || p->suppressed == 1))
  147.     {
  148.         i = p->number;
  149.         if (rrhs[i] + 1 == rrhs[i+1])
  150.         {
  151.         for (j = 0; j < nnulls && i > null_rules[j]; ++j)
  152.             continue;
  153.  
  154.         if (j == nnulls)
  155.         {
  156.             ++nnulls;
  157.             null_rules[j] = i;
  158.         }
  159.         else if (i != null_rules[j])
  160.         {
  161.             ++nnulls;
  162.             for (k = nnulls - 1; k > j; --k)
  163.             null_rules[k] = null_rules[k-1];
  164.             null_rules[j] = i;
  165.         }
  166.         }
  167.     }
  168.     }
  169.  
  170.     for (i = 0; i < nnulls; ++i)
  171.     {
  172.     j = null_rules[i];
  173.     fprintf(verbose_file, "\t%s : .  (%d)\n", symbol_name[rlhs[j]],
  174.         j - 2);
  175.     }
  176.     fprintf(verbose_file, "\n");
  177. }
  178.  
  179. static void print_shifts(register action *p)
  180. {
  181.     register int count;
  182.     register action *q;
  183.  
  184.     count = 0;
  185.     for (q = p; q; q = q->next)
  186.     {
  187.     if (q->suppressed < 2 && q->action_code == SHIFT)
  188.         ++count;
  189.     }
  190.  
  191.     if (count > 0)
  192.     {
  193.     for (; p; p = p->next)
  194.     {
  195.         if (p->action_code == SHIFT && p->suppressed == 0)
  196.         fprintf(verbose_file, "\t%s  shift %d\n",
  197.                 symbol_name[p->symbol], p->number);
  198.     }
  199.     }
  200. }
  201.  
  202.  
  203. static void print_reductions(register action *p, register int defred)
  204. {
  205.     register int k, anyreds;
  206.     register action *q;
  207.  
  208.     anyreds = 0;
  209.     for (q = p; q ; q = q->next)
  210.     {
  211.     if (q->action_code == REDUCE && q->suppressed < 2)
  212.     {
  213.         anyreds = 1;
  214.         break;
  215.     }
  216.     }
  217.  
  218.     if (anyreds == 0)
  219.     fprintf(verbose_file, "\t.  error\n");
  220.     else
  221.     {
  222.     for (; p; p = p->next)
  223.     {
  224.         if (p->action_code == REDUCE && p->number != defred)
  225.         {
  226.         k = p->number - 2;
  227.         if (p->suppressed == 0)
  228.             fprintf(verbose_file, "\t%s  reduce %d\n",
  229.                 symbol_name[p->symbol], k);
  230.         }
  231.     }
  232.  
  233.         if (defred > 0)
  234.         fprintf(verbose_file, "\t.  reduce %d\n", defred - 2);
  235.     }
  236. }
  237.  
  238.  
  239. static void print_gotos(int stateno)
  240. {
  241.     register int i, k;
  242.     register int as;
  243.     register short *to_state;
  244.     register shifts *sp;
  245.  
  246.     putc('\n', verbose_file);
  247.     sp = shift_table[stateno];
  248.     to_state = sp->shift;
  249.     for (i = 0; i < sp->nshifts; ++i)
  250.     {
  251.     k = to_state[i];
  252.     as = accessing_symbol[k];
  253.     if (ISVAR(as))
  254.         fprintf(verbose_file, "\t%s  goto %d\n", symbol_name[as], k);
  255.     }
  256. }
  257.  
  258. static void print_actions(int stateno)
  259. {
  260.     register action *p;
  261.     register shifts *sp;
  262.     register int as;
  263.  
  264.     if (stateno == final_state)
  265.     fprintf(verbose_file, "\t$end  accept\n");
  266.  
  267.     p = parser[stateno];
  268.     if (p)
  269.     {
  270.     print_shifts(p);
  271.     print_reductions(p, defred[stateno]);
  272.     }
  273.  
  274.     sp = shift_table[stateno];
  275.     if (sp && sp->nshifts > 0)
  276.     {
  277.     as = accessing_symbol[sp->shift[sp->nshifts - 1]];
  278.     if (ISVAR(as))
  279.         print_gotos(stateno);
  280.     }
  281. }
  282.  
  283.  
  284. static void print_state(int state)
  285. {
  286.     if (state)
  287.     fprintf(verbose_file, "\n\n");
  288.     if (SRconflicts[state] || RRconflicts[state])
  289.     print_conflicts(state);
  290.     fprintf(verbose_file, "state %d\n", state);
  291.     print_core(state);
  292.     print_nulls(state);
  293.     print_actions(state);
  294. }
  295.  
  296.  
  297.  
  298. void verbose(void)
  299. {
  300.     register int i;
  301.  
  302.     if (!vflag) return;
  303.  
  304.     null_rules = (short *) MALLOC(nrules*sizeof(short));
  305.     if (null_rules == 0) no_space();
  306.     fprintf(verbose_file, "\f\n");
  307.     for (i = 0; i < nstates; i++)
  308.     print_state(i);
  309.     FREE(null_rules);
  310.  
  311.     if (nunused)
  312.     log_unused();
  313.     if (SRtotal || RRtotal)
  314.     log_conflicts();
  315.  
  316.     fprintf(verbose_file, "\n\n%d terminals, %d nonterminals\n", ntokens,
  317.         nvars);
  318.     fprintf(verbose_file, "%d grammar rules, %d states\n", nrules - 2, nstates);
  319. }
  320.